/**
 * jsRookie JavaScript UI module package
 * 
 * Example at: http://www.51jsr.com/web/example/demo.html
 * 
 * Copyright (c) 2010-2011 Benben, http://www.51jsr.com
 * Dual licensed under the MIT and GPL licenses:
 * http://www.opensource.org/licenses/mit-license.php
 * http://www.gnu.org/licenses/gpl.html
 * 
 * Read the related blog post and contact the author at http://51jsr.javaeye.com/blog/649183
 * 
 * Usage: http://www.51jsr.com/web/document/index.html
 * 
 * Tested in IE6 IE7 Chrome Firefox Safari & Opera. Any browser strangeness, please report.
 */

~function(win, dmt, nu, ver, $rules, $tagId, $pc, $ext, $tmp) {
	
	//检测Jsr内核是否已加载
	//if(win.Jsr) return;
	
	//公共常量
	// $rules = {		// abslen:	/[^\x00-\xff]/g,		// format:	/\$\[([^\]]+)\]/g,		// strip:	/<\/?[^>]+>/g,		// toint:	/\D+/g,		// xml:	/([^=]+)=([^&]+)&?/g,		// trim:	/^(\s|\u00A0)+|(\s|\u00A0)+$/g	// },
	// $rules.textNode = ($rules.div = dmt.createElement("div"))		// .appendChild(dmt.createTextNode('')),	// $rules.any = function(x){ return x; },
	//TagID记数器
	$tagId = 0,
	//对象的属性复制
	// $pc = function(destination, source, type) {		// type = type || {};		// for(var i in source)			// (i in type) || (destination[i] = source[i]);		// return destination;	// },
	//对象的单继承
	// $ext = function(destination, source) {		// $pc(destination.prototype, source);		// return destination;	// },
	//Array原生对象扩展
	// $ext(Array, {
		/**
		 * @description 迭代函数
		 * @method $any
		 * @param fn Function|Value 对数组成员进行操作的功能函数,函数可以接受任意个参数，函数的参数为：数组成员|成员下标|其它参数，或者是一个值。
		 * @param rs Array|boolean 中间运算的结果集合，默认值：false。
		 * @since 3.0
		 */
		// $any: function(fn, rs) {			// var t, args, tmp, val;			// rs || (rs = false),			// typeof fn == 'undefined' ? (fn = $rules.any) :	!Jsr.isFunction(fn) && (				// tmp = fn, fn = function(x) {					// return x == tmp;				// }			// ),			// //取其它的参数			// args = Array.apply(null, arguments).slice(2),			// t = this;			// for(var i = -1, len = t.length; ++i < len;) {				// val = fn.apply(t, [t[i]].concat(i, args));				// if(val || val === 0) {					// if(!(rs && rs.add))						// return val;					// rs.add(val);				// }//Endif			// }//Endfor			// return rs;		// }
	// }),
	/***
	 * -CLASS-
	 * @name Function
	 * @package jsr.core.js
	 * @description <C>Function原生对象的扩展</C>
	 * @example function.html
	 * @syntax <C>无</C>
	 * @author benben
	 * @version 2010-04-25
	 * @since 1.0
	 */
	 $ext(Function, {
		/**
		 * -METHOD-
		 * @summary <C>setInterval与setTimeout的封装扩展。</C>
		 * @description <C>为Function对象扩展$defer方法，使setInterval与setTimeout调用更加简单直接。</C>
		 * @method $defer
		 * @return Number
		 * @param time Number <C>函数的延时调用时间。</C>
		 * @param scope Object <C>(可选参数)函数this的作用域对象。</C>
		 * @param type boolean <C>(可选参数)调用setInterval与setTimeout的开关，默认值：false (setTimeout)。</C>
		 * @param args ... <C>(可选参数)任意个参数，函数本身调用时所需的参数。</C>
		 * @since JSR2.0
		 */
		$defer: function(time, scope, type) {
			var t = this, args;
			scope && (args = Array.apply(null, arguments).slice(1)).splice(1, 1);
			return win[(t.$typeTimer = type) ? 
				"setInterval" : "setTimeout"](t.$delegate.apply(t, args || []), time);
		},
		/**
		 * -METHOD-
		 * @summary <C>函数委托</C>
		 * @description <C>返回函数本身且将函数的this指向obj对象。</C>
		 * @method $delegate
		 * @return Function
		 * @param scope Object <C>(可选参数)函数this的作用域对象，默认值：函数本身(this)。</C>
		 * @param args ... <C>(可选参数)委托函数所需的参数序列。</C>
		 * @since JSR2.0
		 */
		$delegate: function(scope) {
			var fn = this, args = Array.apply(null, arguments).slice(1);
			return function() {
				return fn.apply(scope || fn, args);
			}
		},
		/**
		 * -METHOD-
		 * @summary <C>为函数本身创建一个拦截器</C>
		 * @description <C>创建一个拦截器函数，当拦截器函数的返回true时则执行原函数，否则不执行。</C>
		 * @method $interceptor
		 * @return Function
		 * @param fn Function <C>拦截器函数。</C>
		 * @param scope Object <C>(可选参数)调用拦截器函数时，this所指向的作用域对象，默认值：函数本身(this)。</C>
		 * @param args ... <C>(可选参数)原函数所需的参数序列。</C>
		 * @since JSR3.0
		 */
		// $interceptor: function(fn, scope) {			// var t = this;			// return !Jsr.isFunction(fn) ? t : function() {				// return fn.apply(scope || t, arguments) === false ? null :					// t.apply(t, arguments);			// }		// }
	}),
	///EndClass-Function
	Jsr = {
		/***
		 * -CLASS-
		 * @name Jsr.string
		 * @package jsr.core.js
		 * @description <C>对String对象操作的扩展封装</C>
		 * @example jsr.string.html
		 * @syntax <C>无</C>
		 * @author benben
		 * @version 2010-04-23
		 * @since 3.0
		 */
		//$string ----------------------------------------------------------------------------------------------------
		/**
		 * -METHOD-
		 * @summary <C>返回字符串str的绝对长度。</C>
		 * @description <C>本方法多用于求中文字符串的长度，一个中文等于两个英文长度。</C>
		 * @method Jsr.absLen
		 * @return Number
		 * @param str String <C>目标字符串。</C>
		 * @since JSR2.0
		 */
		// absLen: function(str) {			// return str.replace($rules.abslen, "__").length;		// },
		/**
		 * -METHOD-
		 * @summary <C>返回两个字符串是否有包含关系。</C>
		 * @description <C>返回字符串str1是否包含字符串str2。</C>
		 * @method Jsr.contain
		 * @return boolean
		 * @param str1 String <C>被测试字符串。</C>
		 * @param str2 String <C>被包含字符串。</C>
		 * @param separator String <C>(可选参数)分隔符。</C>
		 * @since JSR2.0
		 */
		// contain: function(str1, str2, separator) {			// separator = separator || "";			// return (separator + str1.toLowerCase() + separator)				// .indexOf(separator + str2.toLowerCase() + separator) > -1;		// },
		/**
		 * -METHOD-
		 * @summary <C>字符串的模板操作。</C>
		 * @description <C>将values套用字符串模板，生成新的字符串。</C>
		 * @method Jsr.format
		 * @return String
		 * @param str String <C>字符串模板，关键字的格式为$[keyword]。</C>
		 * @param values JSON <C>关键字值的集合。</C>
		 * @param keyword String <C>关键字与值的对应，可以有多组。</C> values
		 * @since JSR2.0
		 */
		// format: function(str, values) {			// return str.replace(				// $rules.format, function(){					// return values[arguments[1]];				// }			// );		// },
		/**
		 * -METHOD-
		 * @summary <C>字符串的HTML代码形式。</C>
		 * @description <C>返回字符串str的HTML代码形式。</C>
		 * @method Jsr.htmlEncode
		 * @return String
		 * @param str String <C>要处理的目标字符串。</C>
		 * @since JSR3.0
		 */
		// htmlEncode: function(str, $rs) {			// $rules.textNode.data = str,			// $rs = $rules.div.innerHTML,			// $rules.textNode.data = null;			// return $rs;		// },
		/**
		 * -METHOD-
		 * @summary <C>去掉字符串中的HTML标签。</C>
		 * @description <C>过滤掉字符串str中的HTML标签符并返回处理后的结果。</C>
		 * @method Jsr.stripTags
		 * @return String
		 * @param str String <C>要处理的目标字符串。</C>
		 * @since JSR3.0
		 */
		// stripTags: function(str) {			// return str.replace($rules.strip, "");		// },
		/**
		 * -METHOD-
		 * @summary <C>将字符串转换为整型值。</C>
		 * @description <C>过滤掉字符串str中不是数字的字符并返回结果的整型值。</C>
		 * @method Jsr.toint
		 * @return Number
		 * @param str String <C>要处理的目标字符串。</C>
		 * @since JSR3.0
		 */
		// toint: function(str) {			// return str.replace($rules.toint, "") - 0;		// },
		/**
		 * -METHOD-
		 * @summary <C>将URL传参形式转换为XML形式。</C>
		 * @description <C>将URL传参形式转换为XML形式的字符串，并返回处理结果。</C>
		 * @method Jsr.toXMLString
		 * @return String
		 * @param str String <C>要处理的目标字符串。</C>
		 * @param rootTagName String <C>XML根的名称，默认值：root。</C>
		 * @since JSR3.0
		 */
		// toXMLString: function(str, rootTagName, $rs) {			// $rs = [],			// $rs.push("<" + (rootTagName || "root") + ">"),			// $rs.push(str.replace($rules.xml, "<$1><![CDATA[$2]]></$1>")),			// $rs.push("</" + (rootTagName || "root") + ">");			// return $rs.join("");		// },
		/**
		 * -METHOD-
		 * @summary <C>去掉字符串的首尾空格。</C>
		 * @description <C>将字符串str的首尾空格过滤掉，并返回处理结果。</C>
		 * @method Jsr.trim
		 * @return String
		 * @param str String <C>要处理的目标字符串。</C>
		 * @since JSR1.0
		 */
		// trim: function(str) {			// return str.replace($rules.trim, "");		// },
		///EndClass-Jsr.string
		/***
		 * -CLASS-
		 * @name Jsr.array
		 * @package jsr.core.js
		 * @description <C>对Array对象操作的扩展封装</C>
		 * @example jsr.array.html
		 * @syntax <C>无</C>
		 * @author benben
		 * @version 2010-05-10
		 * @since 3.0
		 */
		//$array ----------------------------------------------------------------------------------------------------
		/**
		 * -METHOD-
		 * @summary <C>用指定的功能函数测试数组中的每个成员。</C>
		 * @description <C>本方法将数组的每一个元素，元素下标和可选参数(任意个)做为参数，调用功能函数，当所有的调用结果都为true时，才返回true，否则返回false。</C>
		 * @method Jsr.all
		 * @return boolean
		 * @param arr Array <C>目标数组。</C>
		 * @param fn Function <C>功能函数，此函数可以接受任意个参数，参数顺序：数组成员，成员下标，其它参数。</C>
		 * @param args ... <C>(可选参数)功能函数的其它参数。</C>
		 * @since JSR3.0
		 */
		// all: function(arr, fn) {			// return this.each.apply(null, arguments).length == arr.length;		// },
		/**
		 * -METHOD-
		 * @summary <C>用指定的功能函数遍历数组，并返回结果集合。</C>
		 * @description <C>本方法将数组的每一个元素、元素下标和可选参数（任意个）做为参数，调用功能函数，当有任何一个调用结果为非false时，返回结果，否则返回false。</C>
		 * @method Jsr.any
		 * @return Object|boolean
		 * @param arr Array <C>目标数组。</C>
		 * @param fn Function <C>功能函数，此函数可以接受任意个参数，参数顺序：数组成员，成员下标，其它参数。</C>
		 * @since JSR3.0
		 */
		// any: function(arr, fn) {			// return arr.$any(fn);		// },
		/**
		 * -METHOD-
		 * @summary <C>清空指定的数组。</C>
		 * @description <C>清空指定的数组。</C>
		 * @method Jsr.clear
		 * @return none
		 * @param arr Array <C>要清空的数组。</C>
		 * @since JSR2.0
		 */
		// clear: function(arr) {			// arr.length = 0;		// },
		/**
		 * -METHOD-
		 * @summary <C>浅克隆指定数组。</C>
		 * @description <C>浅克隆指定数组。</C>
		 * @method Jsr.clone
		 * @return Array
		 * @param arr Array <C>目标数组。</C>
		 * @since JSR2.0
		 */
		// clone: function(arr) {			// return [].concat(arr);		// },
		/**
		 * -METHOD-
		 * @summary <C>压缩指定数组。</C>
		 * @description <C>本方法将去除指定数组中值为null、false的元素。</C>
		 * @method Jsr.compact
		 * @return Array
		 * @param arr Array <C>目标数组。</C>
		 * @since JSR3.0
		 */
		// compact: function(arr) {			// return this.each(arr);		// },
		/**
		 * -METHOD-
		 * @summary <C>数组对指定元素的包含检查。</C>
		 * @description <C>检查数组中是否包含指定的元素，包含返回true，否则返回false。</C>
		 * @method Jsr.contains
		 * @return boolean
		 * @param arr Array <C>目标数组。</C>
		 * @param obj Object <C>检查的样本对象。</C>
		 * @since JSR3.0
		 */
		// contains: function(arr, obj) {			// return arr.$any(obj);		// },
		/**
		 * -METHOD-
		 * @summary <C>用指定的功能函数遍历数组，并返回结果集合。</C>
		 * @description <C>本方法将数组的每一个元素、元素下标和可选参数（任意个）做为参数，调用功能函数，并将调用后的结果集合返回。</C>
		 * @method Jsr.each
		 * @return Array
		 * @param arr Array <C>目标数组。</C>
		 * @param fn Function <C>功能函数，此函数可以接受任意个参数，参数顺序：数组成员，成员下标，其它参数。</C>
		 * @param args ... <C>(可选参数)功能函数的其它参数。</C>
		 * @since JSR3.0
		 */
		// each: function(arr, fn) {			// var rs = [];			// rs.add = rs.push,			// fn || (fn = undefined);			// return arr.$any.apply(arr, [fn, rs].concat(Array.apply(null, arguments).slice(2)));		// },
		/**
		 * -METHOD-
		 * @summary <C>返回指定元素的下标。</C>
		 * @description <C>返回指定元素在数组中的下标，若不存在则返回-1。</C>
		 * @method Jsr.indexOf
		 * @return Number
		 * @param arr Array <C>目标数组。</C>
		 * @param obj Object <C>指定的元素对象。</C>
		 * @since JSR2.0
		 */
		// indexOf: function(arr, obj, $rs) {			// return ($rs = arr.$any(function(x, i) {				// return obj == x ? i : false;			// })) === false ? -1 : $rs;		// },
		/**
		 * -METHOD-
		 * @summary <C>在数组中插入元素。</C>
		 * @description <C>在数组指定的下标之前插入一个或多个元素，并返回新的数组。</C>
		 * @method Jsr.insertBefore
		 * @return none
		 * @param arr Array <C>目标数组。</C>
		 * @param idx Number <C>元素对象的下标。</C>
		 * @param obj ... <C>要插入的对象，可以是多个。</C>
		 * @since JSR2.0
		 */
		// insertBefore: function(arr, idx, obj) {			// arr.splice.apply(arr,[idx, 0].concat(Array.apply(null, arguments).slice(2)));		// },
		/**
		 * -METHOD-
		 * @summary <C>对两个数组中的元素进行一对一的操作。</C>
		 * @description <C>本方法将两个数组的同下标元素做为参数，调用功能函数，并将调用后的结果集合返回。</C>
		 * @method Jsr.map
		 * @return Array
		 * @param arr1 Array <C>目标数组1。</C>
		 * @param arr2 Array <C>目标数组2。</C>
		 * @param fn Function <C>(可选参数)功能函数，此函数接受两个参数，参数顺序：数组1成员，数组2成员，默认值：Array。</C>
		 * @since JSR3.0
		 */
		// map: function(arr1, arr2, fn) {			// fn || (fn = Array);			// return this.each(arr1, function(x, i) {				// return fn(x, arr2[i])			// });		// },
		/**
		 * -METHOD-
		 * @summary <C>将数组转换成一个迭代器。</C>
		 * @description <C>将数组转换成一个迭代器，主要应用于对数组普通的遍历。</C>
		 * @method Jsr.iterator
		 * @return Jsr.Iterator
		 * @param arr Array <C>目标数组。</C>
		 * @since JSR3.0
		 */
		// iterator: function(arr, $cursor) {			// $cursor = 0;			// return $pc(new Jsr.Iterator, {				// next: function() {					// $cursor++;					// return this;				// },				// item: function() {					// return arr[$cursor];				// },				// hasNext: function() {					// return $cursor < arr.length;				// },				// reset: function() {					// $cursor = 0;				// }			// });		// },
		/**
		 * -METHOD-
		 * @summary <C>删除数组中指定下标的元素。</C>
		 * @description <C>删除数组中从指定下标开始的len个元素，返回被删除了的元素集合。</C>
		 * @method Jsr.remove
		 * @return Array
		 * @param arr Array <C>目标数组。</C>
		 * @param idx Number <C>要删除的开始下标。</C>
		 * @param len Number <C>(可选参数)要删除元素的连续个数，默认值：1。</C>
		 * @since JSR3.0
		 */
		// remove: function(arr, idx, len) {			// return arr.splice(idx, len || 1);		// },
		///EndClass-Jsr.array
		/***
		 * -CLASS-
		 * @name Jsr.date
		 * @package jsr.core.js
		 * @description <C>对Date对象操作的扩展封装</C>
		 * @example jsr.date.html
		 * @syntax <C>无</C>
		 * @author benben
		 * @version 2010-05-24
		 * @since 3.0
		 */
		//$date ----------------------------------------------------------------------------------------------------
		/**
		 * -METHOD-
		 * @summary <C>返回当前的日期对象。</C>
		 * @description <C>返回当前的系统日期对象。</C>
		 * @method Jsr.now
		 * @return Date
		 * @since JSR3.0
		 */
		// now: function() {			// return new Date;		// },
		/**
		 * -METHOD-
		 * @summary <C>格式化指定的日期对象。</C>
		 * @description <C>按指定的描述表达式格式化date对象，并返回结果。</C>
		 * @method Jsr.formatDate
		 * @return String
		 * @param date Date <C>要格式化的日期对象。</C>
		 * @param pattern String <C>(可选参数)日期格式描述表达式，默认值：yyyy-MM-dd。</C>
		 * @since JSR3.0
		 */
		// formatDate: function(date, pattern) {			// return Jsr.isDate(date) ? (pattern || "yyyy-MM-dd")				// .replace(/yyyy/gi, date.getFullYear()).replace(/MM/g, Jsr.mkZero(date.getMonth() + 1))				// .replace(/DD/gi, Jsr.mkZero(date.getDate())).replace(/hh/gi, Jsr.mkZero(date.getHours()))				// .replace(/mm/g, Jsr.mkZero(date.getMinutes())).replace(/ss/gi, Jsr.mkZero(date.getSeconds())) : "";		// },
		/**
		 * -METHOD-
		 * @summary <C>返回距离指定日期若干天之前/之后的日期对象。</C>
		 * @description <C>返回距离当前日期若干天之前/之后的日期对象。</C>
		 * @method Jsr.getDateFrom
		 * @return Date
		 * @param date Date <C>指定日期对象，默认值：当前日期对象。</C>
		 * @param days Number <C>之前/之后的天数。</C>
		 * @since JSR3.0
		 */
		// getDateFrom: function(date, days) {			// return new Date((Jsr.isDate(date) ? date : new Date).getTime() + days * 86400000);		// },
		/**
		 * -METHOD-
		 * @summary <C>返回指定日期所在月的天数。</C>
		 * @description <C>返回指定日期所在月的天数，如果日期不合法则返回值为0。</C>
		 * @method Jsr.getDaysOfMonth
		 * @return Number
		 * @param date Date <C>指定日期对象。</C>
		 * @since JSR3.0
		 */
		// getDaysOfMonth: function(date) {			// return Jsr.isDate(date) ? new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate() : 0;		// },
		///EndClass-Jsr.date
		/***
		 * -CLASS-
		 * @name Jsr.Cookie
		 * @package jsr.core.js
		 * @description <C>对浏览器Cookie对象操作的扩展封装</C>
		 * @example jsr.cookie.html
		 * @syntax <C>无</C>
		 * @author benben
		 * @version 2010-05-20
		 * @since 3.0
		 */
		//$cookie ----------------------------------------------------------------------------------------------------
		/**
		 * -METHOD-
		 * @summary <C>清除Cookie中所有的对象。</C>
		 * @description <C>清除Cookie中所有的对象数据。</C>
		 * @method Jsr.clearCookie
		 * @return none
		 * @since JSR3.0
		 */
		// clearCookie: function() {			// ($tmp = dmt.cookie).length && (Jsr.each($tmp.replace(/=[^;]+/g, "").split("; "),				// function(x){ Jsr.removeCookie(x); }			// )), $tmp = null;		// },
		/**
		 * -METHOD-
		 * @summary <C>返回Cookie中指定对象的值。</C>
		 * @description <C>返回Cookie中指定对象的值。</C>
		 * @method Jsr.getCookie
		 * @return String
		 * @param keyName String <C>键值名称。</C>
		 * @since JSR3.0
		 */
		// getCookie: function(keyName) {			// $tmp = dmt.cookie.match(new RegExp(keyName + "=([^;]+)"));			// return $tmp && 	decodeURIComponent($tmp.pop());		// },
		/**
		 * -METHOD-
		 * @summary <C>删除Cookie中指定的对象。</C>
		 * @description <C>删除Cookie中指定的对象数据。</C>
		 * @method Jsr.removeCookie
		 * @return none
		 * @param keyName String <C>键值名称。</C>
		 * @since JSR3.0
		 */
		// removeCookie: function(keyName) {			// dmt.cookie = keyName + "=0; expires=Thu, 1 Jan 1970 00:00:00 GMT;";		// },
		/**
		 * -METHOD-
		 * @summary <C>设置Cookie中指定的对象的值。</C>
		 * @description <C>设置Cookie中指定的对象的值。</C>
		 * @method Jsr.setCookie
		 * @return none
		 * @param keyName String <C>键值名称。</C>
		 * @param keyValue String <C>键值。</C>
		 * @param days Number <C>(可选参数)Cookie对象的有效期，以当前天开始计算，单位：天，默认值：无期限。</C>
		 * @param path String <C>可选参数)Cookie的作用域，默认值：/。</C>
		 * @param domain String <C>可选参数)Cookie的作用子域，默认值：null。</C>
		 * @param secure boolean <C>可选参数)Cookie对象传值的方式，默认值：false。</C>
		 * @since JSR3.0
		 */
		// setCookie: function(keyName, keyValue, days, path, domain, secure) {			// var ck = keyName + "=" + encodeURIComponent(keyValue) + "; expires=" + (				// isNaN(days) ? "Fri, 31 Dec 2099 23:59:59 GMT" : 				// new Date(new Date().getTime() + days * 86400000).toGMTString()			// );			// ck += "; ",//path=" + (path || "/"),			// domain && (ck += "; domian=" + domain),			// secure && (ck += "; secure"),			// dmt.cookie = ck;		// },
		///EndClass-Jsr.Cookie
		/***
		 * -CLASS-
		 * @name Jsr
		 * @package jsr.core.js
		 * @description <C>jsRookie内核</C>
		 * @example jsr.core.html
		 * @syntax <C><script type="text/javascript" src="jsr/jsr.core.js?skin=default&loading=Test&debug=true&lang=EN"></script></C>
		 * @param skin String <C>jsRookie JavaScript UI module package 的UI外观声名，默认值: default。</C>
		 * @param lang String <C>jsRookie 的语言包声明，默认值: zh-cn。</C>
		 * @param loading String <C>当前页面显示加载层的提示语，如不加此属性，则不显示加载层。</C>
		 * @param debug boolean <C>(未启用)jsRookie的运行模式，默认值: false。</C>
		 * @author benben
		 * @version 2010-04-20
		 * @since JSR3.0
		 */
		//Jsr ----------------------------------------------------------------------------------------------------
		/**
		 * -PROPERTY-
		 * @summary <C>jsRookie组件的版本。</C>
		 * @description <C>jsRookie组件的版本。</C>
		 * @param ver String
		 * @since JSR2.0
		 */
		// ver: ver,
		/**
		 * -PROPERTY-
		 * @summary <C>浏览器测试标志。</C>
		 * @description <C>是否是Opera浏览器。</C>
		 * @param OP boolean
		 * @since JSR3.0
		 */
		OP: $tmp = /opera/i.test(nu),
		/**
		 * -PROPERTY-
		 * @summary <C>浏览器测试标志。</C>
		 * @description <C>是否是IE浏览器。</C>
		 * @param IE boolean
		 * @since JSR1.0
		 */
		IE: /msie/i.test(nu) && !$tmp,
		/**
		 * -PROPERTY-
		 * @summary <C>浏览器测试标志。</C>
		 * @description <C>是否是FirFox浏览器。</C>
		 * @param FF boolean
		 * @since JSR1.0
		 */
		FF: /firefox/i.test(nu),
		/**
		 * -PROPERTY-
		 * @summary <C>浏览器测试标志。</C>
		 * @description <C>是否是以webkit为核心的浏览器(Chrome|Safari)。</C>
		 * @param SA boolean
		 * @since JSR3.0
		 */
		SA: /webkit/i.test(nu),
		/**
		 * -PROPERTY-
		 * @summary <C>浏览器的当前版本号。</C>
		 * @description <C>浏览器的当前版本号。</C>
		 * @param BV boolean
		 * @since JSR3.0
		 */
		BV: (nu.match(/.+(?:ie|ox|me|on)[\/: ]([\d.]+)/i) || [])[1],
		/**
		 * -PROPERTY-
		 * @summary <C>浏览器的文档类型定义。</C>
		 * @description <C>浏览器的文档类型定义。</C>
		 * @param DTD boolean
		 * @since JSR3.0
		 */
		boxModel: dmt.compatMode != "BackCompat",//document.compatMode === "CSS1Compat"
		/**
		 * -PROPERTY-
		 * @summary <C>浏览器页面中的Head对象。</C>
		 * @description <C>浏览器页面中的Head对象。</C>
		 * @param Head DomElement
		 * @since JSR3.0
		 */
		Head: dmt.getElementsByTagName("head")[0],
		//以下的两个属性放到onReady中取值
		/**
		 * -PROPERTY-
		 * @summary <C>浏览器的页面对象。</C>
		 * @description <C>浏览器的页面对象。</C>
		 * @param DTD DomElement
		 * @since JSR3.0
		 */
		//Page: Jsr.DTD ? dmt.documentElement : dmt.body,
		/**
		 * -PROPERTY-
		 * @summary <C>浏览器页面中的Body对象。</C>
		 * @description <C>浏览器页面中的Body对象。</C>
		 * @param Body DomElement
		 * @since JSR3.0
		 */
		//Body: dmt.body,
		/**
		 * -PROPERTY-
		 * @summary <C>浏览器页面是否处于锁定状态。</C>
		 * @description <C>浏览器页面是否处于锁定状态，在调用组件的模态对话框时，此属性为true。</C>
		 * @param isLocked boolean
		 * @since JSR2.0
		 */
		//isLocked: false,
		/**
		 * -METHOD-
		 * @summary <C>对象的属性复制。</C>
		 * @description <C>将原对象的属性复制给目标对象。</C>
		 * @method Jsr.pc
		 * @return Object
		 * @param destination Object <C>属性复制的目标对象。</C>
		 * @param source Object <C>被复制属性的源对象。</C>
		 * @since JSR2.0
		 */
		// pc: $pc,
		/**
		 * -METHOD-
		 * @summary <C>对象的单继承。</C>
		 * @description <C>对象的单继承，主要以原型扩展为基础。</C>
		 * @method Jsr.extend
		 * @return Object
		 * @param destination Object <C>子对象。</C>
		 * @param source Object <C>父对象。</C>
		 * @since JSR3.0
		 */
		// extend: $ext,
		/**
		 * -METHOD-
		 * @summary <C>扩展obj指定的对象。</C>
		 * @description <C>扩展obj指定的对象，也是js常用的一种继承方式，一般在类中使用。</C>
		 * @method Jsr.calls
		 * @return none
		 * @param obj Object <C>要扩展的对象。</C>
		 * @param args Function <C>(可选参数)执行扩展的方法，这个参数必须为function，可以有多个。</C>
		 * @since JSR3.0
		 */
		calls: function(obj) {
			var args = Array.apply(null, arguments).slice(1);
			for(var i = -1, len = args.length; ++i < len;)
				args[i].call(obj);
		},
		/**
		 * -METHOD-
		 * @summary <C>值的类型测试函数。</C>
		 * @description <C>测试num是否为Number类型。</C>
		 * @method Jsr.isNumber
		 * @return boolean
		 * @param num Number <C>测试的目标对象。</C>
		 * @since JSR3.0
		 */
		// isNumber: function(num) {			// return typeof num == "number";		// },
		/**
		 * -METHOD-
		 * @summary <C>值的类型测试函数。</C>
		 * @description <C>测试str是否为String类型。</C>
		 * @method Jsr.isString
		 * @return boolean
		 * @param str String <C>测试的目标对象。</C>
		 * @since JSR3.0
		 */
		// isString: function(str) {			// return typeof str == "string";		// },
		/**
		 * -METHOD-
		 * @summary <C>值的类型测试函数。</C>
		 * @description <C>测试fn是否为Function类型。</C>
		 * @method Jsr.isFunction
		 * @return boolean
		 * @param fn Function <C>测试的目标对象。</C>
		 * @since JSR3.0
		 */
		// isFunction: function(fn) {			// return typeof fn == "function";		// },
		/**
		 * -METHOD-
		 * @summary <C>值的类型测试函数。</C>
		 * @description <C>测试arr是否为Array类型。</C>
		 * @method Jsr.isArray
		 * @return boolean
		 * @param arr Array <C>测试的目标对象。</C>
		 * @since JSR3.0
		 */
		// isArray: function(arr) {			// return arr && arr.constructor == Array;		// },
		/**
		 * -METHOD-
		 * @summary <C>值的类型测试函数。</C>
		 * @description <C>测试date是否为date类型。</C>
		 * @method Jsr.isDate
		 * @return boolean
		 * @param date Date <C>测试的目标对象。</C>
		 * @since JSR3.0
		 */
		// isDate: function(date) {			// return date && date.constructor == Date;		// },
		/**
		 * -METHOD-
		 * @summary <C>补零函数。</C>
		 * @description <C>为小于指定范围的Number型数据前面补零，如不小于，否则返回Number型数据本身。</C>
		 * @method Jsr.mkZero
		 * @return String
		 * @param num Number|String <C>要补零的目标对象。</C>
		 * @param area Number <C>(可选参数)需要补零的范围，此参数必需为10的整数次方，默认值：10。</C>
		 * @since JSR3.0
		 */
		// mkZero: function(num, area) {			// area = (area || 10) - 0;			// return num < area ? (area + (num += "")).slice(num.length) : num;		// },
		/**
		 * -METHOD-
		 * @summary <C>返回一个新的且唯一的ID字符串。</C>
		 * @description <C>返回一个新的且唯一的ID字符串。</C>
		 * @method Jsr.getTagId
		 * @return String
		 * @since JSR2.0
		 */
		getTagId: function() {
			return "jsrTag-" + $tagId++;
		},
		/**
		 * -METHOD-
		 * @summary <C>返回一个唯一的UUID串。</C>
		 * @description <C>返回一个唯一的UUID串。</C>
		 * @method Jsr.getUuid
		 * @return String
		 * @param length Number <C>(可选参数)UUID串的长度，默认值：32。</C>
		 * @since JSR3.0
		 */
		getUuid: function(s) {
			s = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
			return function(length, $uid) {
				$uid = [];
				for(var i = -1, len = length || 32; ++i < len;)
					$uid.push(s.charAt(0 | Math.random() * 62));
				return $uid.join("");
			}
		}(),
		/**
		 * -METHOD-
		 * @summary <C>模拟window.open功能。</C>
		 * @description <C>当浏览器的弹出窗口功能被阻止时，可以使用此方便来打开新窗口。</C>
		 * @method Jsr.open
		 * @return none
		 * @param url String <C>新窗口的URL地址。</C>
		 * @since JSR3.0
		 */
		open: function(url, $f) {
			dmt.body.appendChild($f = dmt.createElement("form")).action = url,
			$f.target = "_blank", $f.submit(),dmt.body.removeChild($f), $f = null;
		},
		/**
		 * -METHOD-
		 * @summary <C>返回当前浏览器的页面可视尺寸。</C>
		 * @description <C>返回当前浏览器的页面可视尺寸。</C>
		 * @method Jsr.getViewportSize
		 * @return JSON
		 * @since JSR3.0
		 */
		getViewportSize: function() {
			return {
				width: Jsr.Page.clientWidth,	
				height: Jsr.Page.clientHeight
			}
		},
		/**
		 * -METHOD-
		 * @summary <C>返回URL中指定参数名称的值。</C>
		 * @description <C>返回指这作用域的URL中指定参数名称的值。</C>
		 * @method Jsr.getParameter
		 * @return String|undefine
		 * @param name String <C>参数名称。</C>
		 * @param scope Object <C>(可选参数)浏览器窗口句柄，默认值：当前浏览器(window)。</C>
		 * @since JSR3.0
		 */
		// getParameter: function(name, scope) {			// return name && (Jsr.getParameters(name, scope) || [])[0];		// },
		/**
		 * -METHOD-
		 * @summary <C>返回URL中指定参数名称的所有值。</C>
		 * @description <C>返回指这作用域的URL中指定参数名称的所有值。</C>
		 * @method Jsr.getParameters
		 * @return Array|null
		 * @param name String <C>参数名称。</C>
		 * @param scope Object <C>(可选参数)浏览器窗口句柄，默认值：当前浏览器(window)。</C>
		 * @since JSR3.0
		 */
		// getParameters: function(name, scope) {			// return name && (scope = (scope || win).location.search				// .match(new RegExp(name + "=([^&]+)", "g"))) &&  decodeURIComponent(scope.join("!|!")				// .replace(new RegExp(name + "=", "g"), "")).split("!|!");		// },
		/**
		 * -METHOD-
		 * @summary <C>加载指定的CSS样式表文件。</C>
		 * @description <C>加载指定的CSS样式表文件。</C>
		 * @method Jsr.impCSS
		 * @return linkNode
		 * @param href String <C>CSS样式表文件的url地址。</C>
		 * @param media String <C>(可选参数)样式表文件的媒体类型，默认值：all。</C>
		 * @since JSR2.0
		 */
		impCSS: function(href, media) {
			return Jsr.Head.appendChild(
				$pc(document.createElement("link"), {
					href: href, rel: "stylesheet",
					type: "text/css", media: media || "all"
				})
			);
		},
		/**
		 * -METHOD-
		 * @summary <C>加载指定的js脚本文件。</C>
		 * @description <C>加载指定的js脚本文件。</C>
		 * @method Jsr.impScript
		 * @return none
		 * @param src String <C>javascript脚本文件的url地址。</C>
		 * @since JSR2.0
		 */
		impScript: function(src) {
			Jsr.Head.appendChild(
				$pc(document.createElement("script"), {
					type: "text/javascript", src: src
				})
			);
		},
		/**
		 * -METHOD-
		 * @summary <C>为指定的对象添加事件监听。</C>
		 * @description <C>为obj指定的对象添加事件监听，并返回事件的处理函数。</C>
		 * @method Jsr.addEvent
		 * @return Function
		 * @param obj Object|Dom Element <C>要添加事件监听的对象，一般为Dom对象或者是window对象。</C>
		 * @param eventType String <C>事件监听类型。</C>
		 * @param fn Function <C>事件触发时要执行的处理函数。</C>
		 * @since JSR3.0
		 */
		addEvent: function(obj, eventType, fn) {
			Jsr.IE || obj.addEventListener ? (
				fn = fn.$delegate(obj),
				Jsr.IE ? 
					obj.attachEvent("on" + eventType, fn) : 
					obj.addEventListener(eventType, fn, false)
			) : obj["on" + eventType] = fn,
			obj = null;
			return fn;
		},
		/**
		 * -METHOD-
		 * @summary <C>为指定的对象删除指定的事件监听。</C>
		 * @description <C>为obj指定的对象删除指定事件监听。</C>
		 * @method Jsr.removeEvent
		 * @return none
		 * @param obj Object|Dom Element <C>要删除事件监听的对象，一般为Dom对象或者是window对象。</C>
		 * @param eventType String <C>事件监听类型。</C>
		 * @param fn Function <C>事件监听所关联的处理函数。</C>
		 * @since JSR3.0
		 */
		removeEvent: function(obj, eventType, fn) {
			Jsr.IE ?
				obj.detachEvent("on" + eventType, fn) :
				obj.removeEventListener ?
					obj.removeEventListener(eventType, fn, false) : (obj["on" + eventType] = null),
			obj = null;
		},
		/**
		 * -METHOD-
		 * @summary <C>事件委托。</C>
		 * @description <C>为obj对象所指定事件监听创建事件委托。</C>
		 * @method Jsr.EventDelegate
		 * @return EventDelegate
		 * @param obj Object|DomElement <C>进行事件监听的目标对象。</C>
		 * @param eventType String <C>创建事件委托的监听类型。</C>
		 * @param defer Number <C>(可选参数)事件触发后的延迟执行时间，单位：毫秒。</C>
		 * @since JSR2.0
		 */
		EventDelegate: function(obj, eventType, defer) {
			var exec, tID = 0, fnList = {}, delegate = {
				//添加一个名为fnName委托处理项
				add: function(fnName, fn) {
					(fnList[fnName] = fn).$ep = true;
				},
				//释放委托
				destroy: function() {
					obj = obj[eventType] = fnList = exec = null;
				},
				//删除fnName指定的委托处理项
				remove: function(fnName) {
					fnList[fnName].$ep && delete fnList[fnName];
				},
				//复位处理项集合
				reset: function() {
					fnList = {};
				},
				//执行处理项集合中的所有方法
				run: exec = function() {
					for(var i in fnList)
						fnList[i].$ep && fnList[i].call(obj);
				}
			};
			//事件绑定
			obj[eventType] = defer > 0 ? function() {
				clearTimeout(tID),
				tID = exec.$defer(defer);
			} : exec;
			return delegate;
		},
		
	
	
	
		
		
		
		$: function(arg, context) {
			//无参数时返回一个空函数
			if(!arguments.length)
				return function(){};
			//将带有length属性的对象转换为一个数组
			if(!Jsr.isString(arg)) {
				if(arg.length && !arg.tagName) {
					var rs = [];
					for(var i = -1, len = arg.length; ++i < len;)
						rs.push(arg[i]);
					return rs;
				}//Endif
				return arg;
			}//Endif
			//执行选择器
			context = context || dmt;
			if(context.nodeType !== 1 && context.nodetype !== 9)
				return [];
			
			
			
			
		},
		
		querySelectorAll: function(pattern, context) {
			if (!E || typeof E !== "string") {
				return []
			}
			F = F || document;
			if (F.nodeType !== 1 && F.nodeType !== 9) {
				return []
			}
			if (o.qsa) {
				try {
					return F.querySelectorAll(E)
				} catch (G) {
					return querySele(E, [F])
				}
			} else {
				return querySele(E, [F])
			}
		}
	},
	
	
	
/*
［att=value］				完全相等
该属性有指定的确切的值。

［att~=value］				包含
该属性的值必须是一系列用空格隔开的多个值，（比如，class=”title featured home”），而且这些值中的一个必须是指定的值”value”。

［att|=value］				以value-开头
属性的值就是“value”或者以“value”开始并立即跟上一个“-”字符，也就是“value-”。（比如lang=”zh-cn”）

［att^=value］				以value开头
该属性的值以指定值开始。

［att$=value］				最简单的包含
该属性的值包含指定的值（而无论其位置）。

［att*=value］				以value结束
该属性的值以指定的值结束

>	允许你定位某个元素的第一级子元素
+	选择器中的元素有同一个父亲，而且第二个必须紧紧的跟着第一个。
~	是第二个选择其无需紧紧跟随第一个。  (第一个后面的所有指定的兄弟元素)



((?:[_a-zA-Z][\w-]*)|\*)|							//匹配tagName
 (?:#([\w-]+))|								//匹配ID
 (?:\.([\w-]+))|								//匹配className
 (?:\[([a-z]+\w*)+([~\|\^\$\*!]?=)?['"]?([^\]]*?)["']?\])|		//匹配属性
 (?::([\-\w]+)(?:\(['"]?(.+?)["']?\))*)|					//匹配伪类
 (?:\s*((?:[>+~\s,])|$)\s*)				
 
 ----------------------------------------------------------------------------------------------
*/

	
	
	//分析script标签中src里的加载配置参数
	nu = {},
	(ver = ($tmp = Jsr.$(dmt.getElementsByTagName("SCRIPT")).pop()).src.replace(/\s/, ""))
		.replace(/(\w+)=([^&]+)/g, function(a, b, c) {
			nu[b] = a = c;
		}),
	/**
	 * -PROPERTY-
	 * @summary <C>jsRookie组件包的系统路径。</C>
	 * @description <C>jsRookie组件包的系统路径。</C>
	 * @param appPath String
	 * @since JSR2.0
	 */
	Jsr.appPath = ver.match(/^.*(?=jsr\.cor)/i).pop(),
	/**
	 * -PROPERTY-
	 * @summary <C>jsRookie组件包的Skin路径。</C>
	 * @description <C>jsRookie组件包的Skin路径。</C>
	 * @param skinPath String
	 * @since JSR3.0
	 */
	Jsr.skinPath = Jsr.appPath + "resources/skin/" + (nu.skin || "default") + "/",
	//加载多国语言包
	Jsr.impScript(Jsr.appPath + "resources/lang/" + (nu.lang || "zh-cn") + ".js"),
	//页面加载等待层(loading)，需要UI包的支持
	Jsr.loading = nu.loading,
	//动态加载所需的控件声明
	($tmp = Jsr.trim($tmp.innerHTML).split(/[,\s]+/))[0].length && Jsr.each($tmp, function(x) {
		Jsr.impScript(Jsr.appPath + "plugins/" + x + ".js");
	}),
	/**
	 * -PROPERTY-
	 * @summary <C>jsRookie接管浏览器的onload事件。</C>
	 * @description <C>为浏览器的onload事件创建一个事件委托，请参见Jsr.EventDelegate。</C>
	 * @param onload EventDelegate
	 * @since JSR2.0
	 */
	Jsr.onload = Jsr.EventDelegate(win, "onload"),
	/**
	 * -PROPERTY-
	 * @summary <C>jsRookie接管浏览器的onresize事件。</C>
	 * @description <C>为浏览器的onresize事件创建一个事件委托，请参见Jsr.EventDelegate。</C>
	 * @param onresize EventDelegate
	 * @since JSR2.0
	 */
	Jsr.onresize = Jsr.EventDelegate(win, "onresize", 80),
	/**
	 * -EVENT-
	 * @summary <C>jsRookie组件加载完成时的动作事件</C>
	 * @description <C>在jsRookie组件加载完成时，将会触发此事件, 具体的应用请参见方法 {$onReady} 的说明。</C>
	 * @method Jsr.onReadyEvent
	 * @since JSR3.0
	 */
	//Jsr.onReadyEvent,
	/**
	 * -METHOD-
	 * @summary <C>设置jsRookie组件内核的 onReadyEvent 事件处理。</C>
	 * @description <C>当页面组件加载完成时，将执行fnList集合中的方法。</C>
	 * @method Jsr.onReady
	 * @return none
	 * @param fn Function <C>一个或多个自定义操作函数，这些函数将被放入fnList集合中，在事件触发时，统一执行。</C>
	 * @since JSR3.0
	 */
	Jsr.onReady = function() {
		var isReady, fnList = [], run = function() {
			if(isReady) return;
			isReady = true,
			Jsr.Body = dmt.body,
			Jsr.Page = Jsr.DTD ? dmt.documentElement : dmt.body;
			//执行集合中的方法
			while(fnList.length)
				fnList.pop()();
			//关闭loading
			//....
		};
		if(dmt.addEventListener)
			//非IE浏览器的处理
			dmt.addEventListener("DOMContentLoaded", run, null);
		else {
			//IE浏览器中非frame页的处理
			Jsr.IE && win == top && ~function() {
				try {
					dmt.body.doScroll('left');
				}catch(e) {
					return arguments.callee.$defer(10);
				}//Endtry
				run();
			}();
			dmt.onreadystatechange = function() {
				dmt.readyState == 'complete' && (dmt.onreadystatechange = null, run());
			}
		}//Endif
		return function() {
			isReady ?
				Array.apply(null, arguments).$any(function(fn){ fn(); }) : 
				//将参数中的操作函数加入集合
				fnList.push.apply(fnList, arguments);
		}
	}(),
	///EndClass-Jsr
	/***
	 * -CLASS-
	 * @name Jsr.StringBuffer
	 * @package jsr.core.js
	 * @description <C>字符串缓冲器，这个就不用做什么说明了吧！</C>
	 * @example jsr.stringbuffer.html
	 * @param str String <C>默认加入缓冲器的字符串。</C>
	 * @author benben
	 * @version 2010-04-27
	 * @since 3.0
	 */
	Jsr.StringBuffer = function(str) {
		var buffer = !!str ? [str] : [];
		/**
		 * -METHOD-
		 * @summary <C>追加字符串。</C>
		 * @description <C>向字符串缓冲对象中追加字符串。</C>
		 * @method append
		 * @return Jsr.StringBuffer
		 * @param str String <C>要追加的字符串。</C>
		 * @since JSR3.0
		 */
		this.append = function(str) {
			buffer.push(str);
			return this;
		},
		/**
		 * -METHOD-
		 * @summary <C>清空字符串缓冲对象。</C>
		 * @description <C>将字符串缓冲对象内的数据清空。</C>
		 * @method clear
		 * @return Jsr.StringBuffer
		 * @since JSR3.0
		 */
		this.clear = function() {
			buffer.length = 0;
			return this;
		},
		/**
		 * -METHOD-
		 * @summary <C>将字符串缓冲对象内的数据转换成字符串。</C>
		 * @description <C>将字符串缓冲对象内已追加的字符串数据转换成字符串。</C>
		 * @method toString
		 * @return String
		 * @param separator String <C>(可选参数)连接字符串的分隔符，默认值：空串。</C>
		 * @since JSR3.0
		 */
		this.toString = function(separator) {
			return buffer.join(separator || "");
		}
	},
	///EndClass-Jsr.StringBuffer
	/***
	 * -CLASS-
	 * @name Jsr.Iterator
	 * @package jsr.core.js
	 * @description <C>迭代器</C>
	 * @example jsr.iterator.html
	 * @syntax <C>无</C>
	 * @author benben
	 * @version 2010-05-12
	 * @since 3.0
	 */
	$ext(Jsr.Iterator = function(){}, {
		/**
		 * -METHOD-
		 * @summary <C>返回迭代器的指针是否已到结尾。</C>
		 * @description <C>返回迭代器的指针是否已到结尾。</C>
		 * @method hasNext
		 * @return boolean
		 * @since JSR3.0
		 */
		//hasNext: abstract,
		/**
		 * -METHOD-
		 * @summary <C>返回迭代器的指针所指向的成员。</C>
		 * @description <C>将迭代器的指针指向下一个成员。</C>
		 * @method item
		 * @return Object
		 * @since JSR3.0
		 */
		//item: abstract,
		/**
		 * -METHOD-
		 * @summary <C>将迭代器的指针指向下一个成员。</C>
		 * @description <C>将迭代器的指针指向下一个成员。</C>
		 * @method next
		 * @return Jsr.Iterator
		 * @since JSR3.0
		 */
		//next: abstract,
		/**
		 * -METHOD-
		 * @summary <C>将迭代器指针复位。</C>
		 * @description <C>将迭代器指针复位。</C>
		 * @method reset
		 * @return none
		 * @since JSR3.0
		 */
		//reset: abstract,
		/**
		 * -METHOD-
		 * @summary <C>将迭代器转换为一个数组。</C>
		 * @description <C>将迭代器转换为一个数组。</C>
		 * @method toArray
		 * @return Array
		 * @since JSR3.0
		 */
		toArray: function() {
			var $rs = []; this.reset();
			while(this.hasNext()) {
				$rs.push(this.item());
				this.next();
			}//Endwhile
			return $rs;
		}
	}),
	///EndClass-Jsr.Iterator
	
	
	
	/*
	
	jsr.$
	
	EventManager
	
	
	Jsr.dom
	//包含扩展
	function contains(a, b) {
		return a.contains ? a != b && a.contains(b) : !!(a.compareDocumentPosition(arg) & 16);
	}
	
	loading
	
	*/
	//为FireFox的window添加Event对象的Getter
	Jsr.FF && win.__defineGetter__("event", function() {
		var tmp = arguments.callee;
		do {
			if(tmp.arguments[0] instanceof Event)
				return tmp.arguments[0];
		}while(tmp = tmp.caller)
		return null;
	}),
	//触发unload事件时，释放接管的事件委托
	Jsr.addEvent(win, "unload", function() {
		Jsr.onload.destroy(),
		Jsr.onresize.destroy();
	}),
	//隐藏图片工具栏
	dmt.write('<meta http-equiv="imagetoolbar" content="no" />');
	//设置背景图片缓冲
	try {
		dmt.execCommand("BackgroundImageCache", false, true);
	}catch(e){}
	
	nu = ver = $ext= $tmp = null;
}(window, window.document, navigator.userAgent, "3.0.0.100721");
